import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * 用队列实现栈
 * User: xwl
 */

public class MyStack {

    // 定义俩个队列，用来实现栈
    private Queue<Integer> qu1;
    private Queue<Integer> qu2;

    // 构造方法
    public MyStack() {
        this.qu1 = new LinkedList<>();
        this.qu2 = new LinkedList<>();
    }

    /**
     * 压栈
     * @param x:待入队的元素
     */
    public void push(int x) {
        if (!qu1.isEmpty()) {
            qu1.offer(x);
        }else if (!qu2.isEmpty()) {
            qu2.offer(x);
        }else {
            qu1.offer(x);
        }
    }

    /**
     * 出栈
     * @return -1: 栈为空
     */
    public int pop() {
        // 判断栈是否为空
        if (empty()) {
            return -1;
        }
        // 非空队列出队size - 1个元素到另一个队列
        if (!qu1.isEmpty()) {
            while (qu1.size() != 1) {
                qu2.offer(qu1.poll());
            }
            return qu1.poll();
        }else {
            while (qu2.size() != 1) {
                qu1.offer(qu2.poll());            }
            return qu2.poll();
        }
    }

    /**
     * 查看栈顶元素
     * @return -1:栈为空
     */
    public int top() {
        // 判断栈是否为空
        if (empty()) {
            return -1;
        }
        // 定义一个val用来暂存栈顶的值
        int val = 0;
        // 非空队列出队size - 1个元素到另一个队列
        if (!qu1.isEmpty()) {
            while (qu1.size() != 1) {
                qu2.offer(qu1.poll());
            }
            val = qu1.poll();
            qu2.offer(val);
            return val;
        }else {
            while (qu2.size() != 1) {
                qu1.offer(qu2.poll());
            }
            val = qu2.poll();
            qu1.offer(val);
            return val;
        }
    }

    /**
     * 判断栈是否为空
     * @return true:栈空 false:非空
     */
    public boolean empty() {
        return qu1.isEmpty() && qu2.isEmpty();
    }
}